home *** CD-ROM | disk | FTP | other *** search
/ Macwelt 1 / Macwelt DVD 1.toast / Web-Publishing / HTML-Editoren / Alpha ƒ / Tcl / Modes / Matlab mode / matlabEngine.tcl < prev    next >
Encoding:
Text File  |  2000-05-10  |  8.2 KB  |  306 lines
  1. ################################################################################
  2. #
  3. # matlabEngine.tcl, part of the matlab mode package
  4. # 
  5. # Make editing MATLAB files more fun
  6. # 
  7. ################################################################################
  8.  
  9. proc matlabEngine.tcl {} {}
  10.  
  11. ################################################################################
  12. #  Carriage return proc for edit, command, and history windows.
  13. ################################################################################
  14.  
  15. proc bind::MATLcarriageReturn {} {
  16.     global MATLmodeVars
  17.  
  18.     if {[matlabIsShell]} {
  19.         matlabDoShellLine
  20.     } elseif {[matlabIsHist]} {
  21.         matlabAddCommandHistory [matlabDoSelectionOrLine]
  22.         bringToFront $MATLmodeVars(CmdHistWinName)
  23.     } else {
  24.         if { [isSelection] } { deleteSelection }
  25.         if [text::isInComment [getPos] start] {
  26.             insertText "\r${start}"
  27.             return
  28.         }
  29.         
  30.         insertText "\r"
  31.         
  32.         if {$MATLmodeVars(elecReturn)} {
  33.             previousLine
  34.             MATL::indentLine
  35.             goto [nextLineStart [getPos]]
  36.             MATL::indentLine
  37.         }            
  38.     }
  39. }
  40.  
  41. ################################################################################
  42. #  Arrow key replacement
  43. ################################################################################
  44.  
  45. proc matlabUp {} {
  46.     if {[matlabIsShell]} {
  47.         matlabPrevCommand
  48.     } elseif {[matlabIsHist]} {
  49.         upBrowse
  50.     } else {
  51.         previousLine
  52.     }
  53. }
  54.  
  55. proc matlabDown {} {
  56.     if {[matlabIsShell]} {
  57.         matlabNextCommand
  58.     } elseif {[matlabIsHist]} {
  59.         downBrowse
  60.     } else {
  61.         nextLine
  62.     }
  63. }
  64.  
  65.  
  66. #################################################################################
  67. #  cmd-double clicking, edit or get help on command
  68. ################################################################################
  69.  
  70. proc MATL::DblClick {from to shift option control} {    
  71.     global MATLmodeVars
  72.     
  73.     set DblClickEdits [expr !$control == $MATLmodeVars(DblClickEdits)]
  74.  
  75.     # Force command names to lower case.
  76.     # (Mac filenames are case-insensitive, anyway)
  77.     set text [string tolower [getText $from $to]]
  78.     
  79.     if {! $DblClickEdits} {
  80.         getMatlabHelp $text
  81.     } else {
  82.         MATL::editMfile $text
  83.     }
  84. }
  85.  
  86.  
  87. ################################################################################
  88. #  Auto-indentation
  89. #        1. Identify previous line ignoring comments
  90. #        2.    Find leading whitespace for previous line
  91. #        3.    Increase whitespace if previous line starts a block
  92. #        4.    Decrease whitespace if current line ends a block
  93. #     5. Eliminate whitespace if current line starts a procedure
  94. ################################################################################
  95.  
  96. proc MATL::indentLine {} {
  97.     
  98.     # Comment Pattern
  99.     set comPat {^[ \t]*%([^\r\n]*)}
  100.     
  101.     # Begining of block pattern
  102.     set bobPat {^[ \t]*(if|else|elseif|for|switch|case|while|otherwise)[ \t\r\n;,%]}
  103.     
  104.     # End of block pattern
  105.     set eobPat {^[ \t]*(end|else|elseif|case|otherwise)[ \t\r\n;,%]}
  106.     
  107.     # Begining and end of block pattern
  108.     set baeobPat {^[ \t]*(if|else|elseif|for|case|otherwise)[^%]*[ \t]+(end)[ \t\r\n;,%]}
  109.     
  110.     # Function Line Pattern
  111.     set funPat {^[ \t]*(function)[ \t]+([[]*[^][\n\r]+[]]*[ \t]*=[ \t]*)*([a-z0-9_]+)[ \t]*([(]+[^)(\n\r]+[)]+)*}
  112.     
  113.     # Get line to indent
  114.     set beg [lineStart [getPos]]
  115.     set text [getText $beg [nextLineStart $beg]]
  116.     regexp -- {^[ \t]*} $text white
  117.     set len [string length $white]
  118.         
  119.     # Init some vars
  120.     set begCmt $beg
  121.     set prvPos $beg
  122.     set endCmt $beg
  123.     set prvPos $beg
  124.     
  125.     # Find last previous non-comment line and get its leading whitespace
  126.         
  127.     while {[pos::compare $begCmt <= $prvPos] && [pos::compare $endCmt >= $prvPos]} {
  128.     
  129.     # Find the last non-blank line that precedes the comment block
  130.     if {![catch {search -f 0 -r 1 -s -i 0 -m 0 {^[ \t]*[^ \t\r]} [pos::math $begCmt -1]} lst]} {    
  131.             
  132.         set prvPos [lindex $lst 0]
  133.         set line [getText [lindex $lst 0] [nextLineStart [lindex $lst 0]]]
  134.         set lwhite [getText [lindex $lst 0] [pos::math [lindex $lst 1] - 1]]
  135.             
  136.         # Find the next preceding comment block
  137.         if {![catch {search -f 0 -r 1 -s -i 0 -m 0 $comPat $prvPos} lstCmt]} {
  138.         set begCmt [lindex $lstCmt 0]
  139.         set endCmt [lindex $lstCmt 1]
  140.         } else {
  141.         break
  142.         }
  143.             
  144.     } else {
  145.         # Handle search failure at top-of-file
  146.         if {[pos::compare $beg !=  [minPos]]} {
  147.         set line [getText [minPos] [nextLineStart [minPos]]]
  148.         } else {
  149.         set line "%\r"
  150.         }
  151.         set lwhite ""
  152.         break
  153.     }
  154.     }
  155.     
  156.     # If the preceeding line begins a block increase the whitespace
  157.     if {[regexp -nocase -- $bobPat $line]} {
  158.     # but not if it also ended the block
  159.     if {![regexp -nocase -- $baeobPat $line]} {
  160.         append lwhite "\t"
  161.     }
  162.     }
  163.  
  164.     # If the current line ends a block decrease the whitespace
  165.     if {[regexp -nocase -- $eobPat $text]} {
  166.     set lwhite [string range $lwhite 0 [expr [string length $lwhite] - 2]]
  167.     }
  168.     
  169.     # If the current line starts a new function use no whitespace
  170.     if {[regexp -nocase -- $funPat $text allofit subType subVars subName]} {
  171.     set lwhite ""
  172.     }
  173.  
  174.     # Put in the white space
  175.     if {$white != $lwhite} {
  176.     replaceText $beg [pos::math $beg + $len] $lwhite
  177.     }
  178.     goto [pos::math $beg + [string length $lwhite]]
  179. }
  180.  
  181.  
  182. ################################################################################
  183. #  Electric Semicolon
  184. ################################################################################
  185.  
  186. proc MATL::electricSemi {} {
  187.  
  188.     set pos [getPos]
  189.     set start [lineStart $pos]
  190.     set text [getText $start $pos]
  191.     
  192.     # Check if we are in a string or an array
  193.     if {[string first {'} $text] != -1 || [string first {[} $text] != -1} {
  194.     set quotes 0
  195.     set lefts 0
  196.     set rights 0
  197.     set len [string length $text]
  198.     for {set i 0} {$i < $len} {incr i} {
  199.         switch  -- [string index "$text" $i] {
  200.         \[    { incr lefts }
  201.         \]    { incr rights }
  202.         \'    { incr quotes }
  203.         }
  204.     }
  205.     if {[expr $quotes % 2]} {
  206.         insertText ";"
  207.         return
  208.     } elseif    {$lefts != $rights} {
  209.         insertText ";"
  210.         return
  211.     }
  212.     }
  213.     
  214.     insertText ";"
  215.     bind::MATLcarriageReturn
  216. }
  217.  
  218.  
  219. ################################################################################
  220. #  Electric Semicolon Jump
  221. #  Use with templates on last line of a block
  222. ################################################################################
  223.  
  224. proc MATL::electricSemiJump {} {
  225.     insertText ";"
  226.     ring::+
  227. }
  228.  
  229. ################################################################################
  230. #  Set the named marks
  231. ################################################################################
  232.  
  233. proc MATL::MarkFile {} {
  234.     global MATLmodeVars
  235.     set pos [minPos]
  236.     
  237.     set funPat {^[ \t]*(function)[ \t]+([[]*[^][\n\r]+[]]*[ \t]*=[ \t]*)*([a-z0-9_]+)[ \t]*([(]+[^)(\n\r]+[)]+)*}
  238.     
  239.     while {![catch {search -s -f 1 -r 1 -m 0 -i 0 $funPat $pos} res]} {
  240.     set start [lindex $res 0]
  241.     set end [pos::math [lindex $res 1] + 1]
  242.     set text [getText $start $end]
  243.     if {[regexp -nocase -- $funPat $text allofit subType subVars subName]} {
  244.         set locs($subName) [lineStart $start]
  245.     }
  246.     set pos $end
  247.     }
  248.     
  249.     if {[info exists locs]} {
  250.     foreach f [lsort -ignore [array names locs]] {
  251.         setNamedMark $f $locs($f) $locs($f) $locs($f)
  252.     }
  253.     }
  254. }
  255.  
  256. ################################################################################
  257. #  Edit an m-file if available, else get help if built-in
  258. ################################################################################
  259.  
  260. proc MATL::editMfile {fileName} {
  261.     
  262.     set varPat {is a (.+)}
  263.     set pathPat {(.*):([^:]*)}
  264.     
  265.     set res [matlabWhichFile $fileName]
  266.     if {$res == ""} {return}
  267.  
  268.     # If variable or built-in function, get help info.
  269.     if {[regexp -- $varPat $res type]} {
  270.         getMatlabHelp $fileName
  271.         
  272.     # If it's an m-file open it.
  273.     } elseif {[regexp -- $pathPat $res dir fname]} {
  274.         if {[catch {edit -c $res}]} {
  275.             beep
  276.             alertnote "Could not open m-file \"$res\""
  277.         } else {
  278.             icon -o
  279.         }
  280.         
  281.     # If MATLAB doesn't recognize it, check if it's an
  282.     # m-file in the same folder as the current script
  283.     # If not, just display MATLAB's original response.
  284.     } else {
  285.         set path [absolutePath :${fileName}.m] 
  286.         if [file exists $path] {
  287.             if {[catch "edit -c \"$path\""]} {
  288.                 beep
  289.                 alertnote "Could not open m-file \"$res\""
  290.             } else {
  291.                 icon -o
  292.             }
  293.         } else {
  294.             # Now it could be a contents.m
  295.             set resC [matlabWhichFile "$fileName:contents.m"]
  296.             if {$resC == ""} {return}
  297.             if {[catch {edit -c $resC}]} {
  298.                 beep
  299.                 alertnote "Could not open m-file \"$res\""
  300.             } else {
  301.                 icon -o
  302.             }
  303.        }
  304.     }
  305. }
  306.